Instance 0

Class510.getDataFromURL(String url){
        URL theURL = new URL(url);
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(theURL.openStream()));
        while ((line = bufferedReader.readLine()) != null) data += line;
        bufferedReader.close();
}


Instance 1

Class410.readSampleFile(String url){
    BufferedReader br = new BufferedReader(
        new InputStreamReader(getClass().getResourceAsStream(url)));
    while ((line = br.readLine()) != null) {
      fileString += line += "\n";
    }
    br.close();
}


Instance 2

Class320.testURLPathToInputStream(){
        BufferedReader in = new BufferedReader(
                new InputStreamReader(ResourceUtil.pathToInputStream(URL_PATH)));
        while ((inputLine = in.readLine()) != null)
            System.out.println(inputLine);
        in.close();
}


Instance 3

Class140.exec(String cmd){
        Process p = Runtime.getRuntime().exec(cmd);
        p.waitFor();
        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();
}


Instance 4

Class690.readAdaptorsFile(File checkpoint){
    log.info("starting adaptors listed in " + checkpoint.getAbsolutePath());
    BufferedReader br = new BufferedReader(new InputStreamReader(
        new FileInputStream(checkpoint)));
    while ((cmd = br.readLine()) != null)
      processAddCommand(cmd);
    br.close();
}


Instance 5

Class740.getContent(ResourceCollection rc,String path)#0{
        BufferedReader br = new BufferedReader(new InputStreamReader(rc.addPath(path).getURL().openStream()));
        while((line=br.readLine())!=null)
            buffer.append(line);
        br.close();        
}


Instance 6

Class400.readInputStream(InputStream is,List<String> stringList){
    BufferedReader in = new BufferedReader(new InputStreamReader(is));
    while ((line = in.readLine()) != null) {
      stringList.add(line);
    }
    in.close();
}


Instance 7

Class10.loadWords(){
    InputStream inputStream = LoadData.class.getResourceAsStream("words.txt");
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    while ((word = reader.readLine()) != null) {
      words.add(word.trim());
    }
    reader.close();
}


Instance 8

Class20.read(File file)#0{
    if (!file.exists()) return ret;
      BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file),Helper.utf8));
      String line; while ((line = br.readLine()) != null) ret.add(line);
      br.close();
}


Instance 9

Class340.printTextFile(FileSystem fs,Path p){
    BufferedReader in = new BufferedReader(new InputStreamReader(fs.open(p)));
    while ((line = in.readLine()) != null) {
      System.out.println("  Row: " + line);
    }
    in.close();
}


Instance 10

Class300.dumpProcessOutput(Process p){
        istream = new BufferedReader(new InputStreamReader(p.getInputStream()));
        while ((line = istream.readLine()) != null) {
            System.out.println(line);
        }
}


Instance 11

Class140.dumpPingResults(final Process process){
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            while ((line = reader.readLine()) != null) {
                Log.d(TAG, line);
            }
}


Instance 12

Class650.consumeResponse(InputStream is){
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            while ((line = reader.readLine()) != null) {
                
            }
            is.close();
}


Instance 13

Class230.stopSauceTunnel(){
        tunnel_process = Runtime.getRuntime().exec("ruby sauce-tunnel-delete.rb " + tunnel_id);
        BufferedReader input = new BufferedReader
                        (new InputStreamReader(tunnel_process.getInputStream()));
        while ((line = input.readLine()) != null) {
            System.out.println(line);
        }
}


Instance 14

Class310.dumpOutput(Process process){
        InputStream is = process.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        while ((line = br.readLine()) != null) {
          System.out.println(line);
        }
}


Instance 15

Class720.main(String[] args)#1{
      BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
      while (null != (s = r.readLine()))
         p.println(s);
      p.close();
}


Instance 16

Class260.readStream(InputStream input){
      BufferedReader reader = new BufferedReader(new InputStreamReader(input));
      while ((line = reader.readLine()) != null) {
        LOG.info(line);
      }
}


Instance 17

Class740.runConsole(){
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    while((s = in.readLine()) != null) {
      dump(s, false);
      System.out.print("> ");
    }
}


Instance 18

Class20.run(){
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        while ((s = reader.readLine()) != null) {
          os.println(s);
        }
}


Instance 19

Class570.convertInputStreamToString(InputStream inputStream){
        BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(inputStream));
        while((line = bufferedReader.readLine()) != null)
            result += line;
        inputStream.close();
}


Instance 20

Class230.initStopWords(File file)#0{
    logger.info("reading stop words file: " + file.getAbsolutePath());
    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF-8"));
    while ((line = reader.readLine())!=null)
      stopWords.add(line.trim());
    logger.info(stopWords.size() +" stop words were read");
}


Instance 21

Class630.loadIndex()#0{
    InputStream stream = GNU30Plugin.class.getResourceAsStream("/resources/gnu30/images.txt");
    BufferedReader br = new BufferedReader(new InputStreamReader(stream));
    while ( (line = br.readLine()) != null ) {
      String path = "/images/gnu30/" + line.trim();
      ArrayList<BufferedImage> bi = this.loadGifObject(GNU30Plugin.class.getResourceAsStream(path));
      this.images.add(bi);
    }
}


Instance 22

Class140.loadFile(String resourcePath)#1{
  BufferedReader r = new BufferedReader(new InputStreamReader(in, Charset.forName("utf-8")));
  while ((nextLine = r.readLine()) != null) {
      w.write(nextLine);
      w.write(String.format("%n")); // platform dependent newline character
  }
}


Instance 23

Class190.W3CLogParser(InputStream is){
    BufferedReader buf = new BufferedReader(new InputStreamReader(is));
    while ((line = buf.readLine()) != null) {
      List<String> fields = Arrays.asList(line.split(DELIMITER));
      fieldDef_.put(fields.get(0), fields.subList(1, fields.size()));
    }
}


Instance 24

Class620.importBooks(InputStream exportStream,Importer.CoverFinder coverFinder,Importer.OnImporterListener listener,int importFlags)#0{
    BufferedReader in = new BufferedReader(new InputStreamReader(exportStream, UTF8),BUFFER_SIZE);
    while ((line = in.readLine()) != null) {
      importedString.add(line);
    }
    return importBooks(importedString, coverFinder, listener, importFlags);
}


Instance 25

Class230.run(){
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                while ( (line = br.readLine()) != null)
                    window.consoleTab.println(type + ":" + line);
                window.consoleTab.println(e);
}


Instance 26

Class410.main(String[] args){
  BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
  while ((line = reader.readLine()) != null)
      System.out.println(pseudolocalise(line));
}


Instance 27

Class10.dumpStream(InputStream stream){
            new BufferedReader(new InputStreamReader(stream));
        while ((line = in.readLine()) != null) {
            outStream.println(line);
        }
}


Instance 28

Class570.loadSource(InputStream is)#0{
      BufferedReader br = new BufferedReader(new InputStreamReader(is, "utf-8"));
      while ((line = br.readLine()) != null) {
        addSourceLineEntry(line);
      }
}


Instance 29

Class430.run()#0{
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        while ((line = br.readLine()) != null)
          result.append(line).append("\n");
}


Instance 30

Class220.go()#1{
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    while ((line = in.readLine()) != null) {
      String out = line.replace(find, replace);
      System.out.println(out);
    }
}


Instance 31

Class350.test1(){
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filepath), "UTF-8"));
    while((line = br.readLine())!=null){
      System.out.println(line);
    }
}


Instance 32

Class410.textFileToString(String fileLocation){
    BufferedReader br = new BufferedReader(
        new InputStreamReader(getClass().getResourceAsStream(fileLocation)));
    while ((line = br.readLine()) != null) {
      fileString += line;
    }
    br.close();
}


Instance 33

Class660.batchRun(){
      Reader r = "-".equals(inputFile) ? new InputStreamReader(System.in) : new FileReader(inputFile);
      BufferedReader br = new BufferedReader(r);
         for (String line = br.readLine(); line != null; line = br.readLine()) {
            execute(line);
         }
         br.close();
}


Instance 34

Class700.fromJSON(final InputStream in)#0{
        final BufferedReader bfs = new BufferedReader(new InputStreamReader(in));
        while ((line = bfs.readLine()) != null) {
            vertices.add(FaunusGraphSONUtility.fromJSON(line));
        }
        bfs.close();
}


Instance 35

Class670.readAll(InputStream stream)#0{
        BufferedReader err = new BufferedReader( new InputStreamReader( stream ) );
        for ( String line; null != (line = err.readLine()); )
        {
            message.append( line ).append( '\n' );
        }
        err.close();
}


Instance 36

Class680.regularReadIntoList(File file,List<String> stringList){
    FileInputStream fis = new FileInputStream(file);
    BufferedReader in = new BufferedReader(new InputStreamReader(fis));
    while ((line = in.readLine()) != null) {
      stringList.add(line);
    }
    in.close();
}


Instance 37

Class420.printOutput(Process p){
            BufferedReader input = new BufferedReader (new InputStreamReader(p.getInputStream()));
            while ((line = input.readLine()) != null) {
                System.out.println(line);
                System.out.flush();
            }
            input.close();
}


Instance 38

Class260.readOvfContent(String ovfFilePath)#0{
        BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(ovfFilePath),"UTF-8"));
        while ((lineStr = in.readLine()) != null) {
            strContent.append(lineStr);
        }
        in.close();
}


Instance 39

Class0.readOvfContent(String ovfFilePath)#0{
    BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(ovfFilePath)));  
    while ((lineStr = in.readLine()) != null) {  
      strContent.append(lineStr);  
    }  
    in.close();  
}


Instance 40

Class240.readUTF8Textfile(InputStream pInputStream)#1{
    Reader r = new InputStreamReader(pInputStream, "utf-8");
    BufferedReader in = new BufferedReader(r);
    while ((line = in.readLine()) != null)
      content.append(line).append(lineFeed);
    in.close();
}


Instance 41

Class370.fromJSON(final InputStream in)#0{
        final BufferedReader bfs = new BufferedReader(new InputStreamReader(in));
        while ((line = bfs.readLine()) != null) {
            vertices.add(fromJSON( line));
        }
        bfs.close();
}


Instance 42

Class50.readAdaptorsFile(File checkpoint){
    BufferedReader br = new BufferedReader(new InputStreamReader(
        new FileInputStream(checkpoint)));
    while ((cmd = br.readLine()) != null)
      processCommand(cmd);
    br.close();
}


Instance 43

Class20.getRom(Socket client){
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            return br.readLine();
            br.close();
}


Instance 44

Class170.go(){
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    while ((line = in.readLine()) != null) {
      for (String part : line.split(find)) {
        writeString(part);  // write key
        writeInt(1);        // write value
      }
    }
}


Instance 45

Class650.readFrom(String path){
    File file = new File(path);
    System.out.println("Trying to load accessToken from file " + file.getAbsolutePath());
    FileInputStream fis = new FileInputStream(file);
    InputStreamReader isr = new InputStreamReader(fis);
    BufferedReader br = new BufferedReader(isr);
    String token = br.readLine();
    br.close();
}


Instance 46

Class110.getPortFromShutdownPortFile(String portFile){
        BufferedReader r = new BufferedReader(new InputStreamReader(new FileInputStream(portFile)));
        String portStr = r.readLine();
        port = Integer.parseInt(portStr);
        r.close();
}


Instance 47

Class50.verifyGzipFile(String filename,String msg)#1{
    BufferedReader r = new BufferedReader(new InputStreamReader(
        new GZIPInputStream(new FileInputStream(filename))));
      String line = r.readLine();
      assertEquals("Got invalid line back from " + filename, msg, line);
      r.close();
}


Instance 48

Class470.getWordCountInHSpellFolder(InputStream inputStream){
        final BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, Charset.defaultCharset()));
        final String sizes = reader.readLine();
        reader.close();
        tmp = sizes.indexOf(' ', sizes.indexOf('\n'));
        tmp = Integer.parseInt(sizes.substring(tmp + 1).trim());
}


Instance 49

Class70.loadFrameworkFactory(ClassLoader classLoader){
        if (factoryClass == null) {
            InputStream is = classLoader.getResourceAsStream("META-INF/services/" + FrameworkFactory.class.getName());
            BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            factoryClass = br.readLine();
            br.close();
        }
        FrameworkFactory factory = (FrameworkFactory) classLoader.loadClass(factoryClass).newInstance();
}


Instance 50

Class340.readFirstLine(final Configuration mrConfig,final Path pathIn){
    final FSDataInputStream fdi = pathIn.getFileSystem(mrConfig).open(pathIn);
    final BufferedReader d = new BufferedReader(new InputStreamReader(fdi));
    final String line = d.readLine();
    d.close();
}


Instance 51

Class10.getService(String name){
        BufferedReader fin = new BufferedReader(new InputStreamReader(new FileInputStream(name)));
        returnValue = fin.readLine();
        fin.close();
}


Instance 52

Class590.assertFileContent(final InputStream stream){
        final BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
        final String line = reader.readLine();
        assertEquals(line, TEST_MESSAGE);
        reader.close();
}


Instance 53

Class310.check(Object content){
                                 InputStream stream = (InputStream)content;
                                 BufferedReader data = new BufferedReader(new InputStreamReader(stream));
                                 assertEquals(CONTENT_STRING, data.readLine());
                                 assertEquals(-1, data.read());
                                 data.close();
}


Instance 54

Class100.main(String[] args){
    Runtime r = Runtime.getRuntime();
    Process p = r.exec(nargs);
      new BufferedReader(new InputStreamReader(p.getInputStream()));
    while ((line = is.readLine()) != null)
      System.out.println(line);
}


Instance 55

Class640.execute(final String file)#0{
    final FileInputStream fstream = new FileInputStream(file);
    final DataInputStream in = new DataInputStream(fstream);
    final BufferedReader br = new BufferedReader(new InputStreamReader(in));
    while ((this.line = br.readLine()) != null) {
      executeLine();
    }
    in.close();
}


Instance 56

Class80.read(InputStream in)#0{
    BufferedReader r = new BufferedReader(new InputStreamReader(in), 1000);
    for (String line = r.readLine(); line != null; line = r.readLine()) {
      sb.append(line);
    }
    in.close();
}


Instance 57

Class20.read(InputStream in)#0{
        BufferedReader r = new BufferedReader(new InputStreamReader(in), 1000);
        for (String line = r.readLine(); line != null; line = r.readLine()) {
            sb.append(line);
        }
        in.close();
}


Instance 58

Class510.readResource(String path)#0{
    InputStream s = LoadUsers.class.getResourceAsStream(path);
    BufferedReader reader = new BufferedReader(new InputStreamReader(s));
    while ((line = reader.readLine()) != null) {
      lines.add(line);
    }
    s.close();
}


Instance 59

Class380.getSpecCommandList()#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(specfilein));
    while((cmd=reader.readLine()) != null){
      cmdlist.add(cmd);
    }
}


Instance 60

Class270.importLines(InputStream in)#0{
    BufferedReader buffered = new BufferedReader(new InputStreamReader(in));
    while ((line = buffered.readLine()) != null)   {
      lines.add(line);
    }
}


Instance 61

Class110.getCharContent(boolean b){
                InputStream stream = getClass().getClassLoader().getResource(packagePrefix + fileName).openStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
                for (String line = null; (line = reader.readLine()) != null; str += line + "\n")
                    ;
}


Instance 62

Class390.verifyResult(){
    BufferedReader reader = new BufferedReader(new InputStreamReader(
        fs.open(new Path(OUTPUT + "/part-00000"))));
    while ((line = reader.readLine()) != null) {
      String[] temp = line.split("\t");
      assertTrue(outResults.containsKey(temp[0]));
      assertEquals(temp[1], outResults.get(temp[0]));
    }
}


Instance 63

Class480.getFileContents(IPath path)#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    for (String str = reader.readLine(); str != null; str = reader.readLine()) {
      writer.write(str);
      writer.write('\n');
    }
    return writer.toString();
}


Instance 64

Class320.dumpRequestContent(InputStream is)#3{
                BufferedReader r = new BufferedReader(new InputStreamReader(is));
                while ((l = r.readLine()) != null)
                    if (DEBUG) Log.i(TAG, l);
}


Instance 65

Class30.run()#0{
        BufferedReader input = new BufferedReader(new InputStreamReader(p1.getErrorStream()));
          while ((line = input.readLine()) != null) {
            System.out.println(line);
          }
}


Instance 66

Class160.run()#1{
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            while((line = reader.readLine()) != null) {
                logger.log(line);
            }
}


Instance 67

Class630.getContentString(InputStream inStream)#0{
        BufferedReader bufferedReader2 = new BufferedReader( 
                new InputStreamReader(inStream, NetEncoding));
        for (String s = bufferedReader2.readLine(); s != null; s = bufferedReader2 
                .readLine()) { 
            builder.append(s); 
        }
        return builder.toString();
}


Instance 68

Class10.getEntityAsString(InputStream entityStream)#1{
        BufferedReader reader = new BufferedReader(new InputStreamReader(entityStream));
        while ((line = reader.readLine()) != null) {
            writer.write(line);
        }
        return writer.toString();
}


Instance 69

Class320.main(String[] args)#0{
    BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
    for(String line; (line = is.readLine()) != null; ){
      Annotation ann = pipeline.process(line, null, timeAnnotator);
      System.out.println(ann.get(TimeAnnotations.TimexAnnotations.class));
      System.out.print("> ");
    }
}


Instance 70

Class240.readInt(String filename){
    URL url = new URL(filename);
    InputStream stream = url.openStream();
    InputStreamReader isr = new InputStreamReader(stream);
    BufferedReader reader = new BufferedReader(isr);
    return Integer.parseInt(reader.readLine());
}


Instance 71

Class670.xmlPullParserFromSocket(InputStream socketInputStream)#1{
        BufferedReader br = new BufferedReader(new InputStreamReader(socketInputStream));
        while ((line = br.readLine()) != null && line.length() > 0); // eat the HTTP POST headers
}


Instance 72

Class400.printLines(final String what,final InputStream in){
    final BufferedReader r = new BufferedReader(new InputStreamReader(in));
    while ((line = r.readLine()) != null) {
      LOG.info('(' + what + ") " + line);
    }
}


Instance 73

Class170.go(int seconds)#0{
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    while ((line = in.readLine()) != null) {
      Thread.sleep(seconds * 1000L);
      System.out.println(line);
    }
}


Instance 74

Class50.run()#0{
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        while ((line = br.readLine()) != null)
          System.out.println(type + ">" + line);
}


Instance 75

Class380.getHtml(InputStream input)#1{
        BufferedReader reader = new BufferedReader(new InputStreamReader(input));
        while ((line = reader.readLine()) != null) {
            pw.write(line);
        }
}


Instance 76

Class180.main(String[] args)#0{
      new BufferedReader(new InputStreamReader(System.in));
    while ((line = is.readLine()) != null) {
      df.process(line);
    }
}


Instance 77

Class690.run()#0{
      InputStreamReader isr = new InputStreamReader(is);
      BufferedReader br = new BufferedReader(isr);
      while ((line = br.readLine()) != null)
        System.out.println(type + ">" + line);
}


Instance 78

Class430.run()#0{
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        while ((line = br.readLine()) != null)
          System.out.println(type + ">" + line);
}


Instance 79

Class580.main(String[] args)#0{
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    while ((s = bufferedReader.readLine()) != null)
      System.out.println(s);
}


Instance 80

Class300.print(InputStream in){
        BufferedReader r = new BufferedReader( new InputStreamReader( in ) );
        while( (line = r.readLine()) != null ) {
            System.out.println( line );
        }
}


Instance 81

Class470.saveFile(InputStream st,File testFile){
    BufferedReader r = new BufferedReader(new InputStreamReader(st));
      while ((line = r.readLine()) != null) {
        wr.println(line);
      }
}


Instance 82

Class70.assertWarDeployed()#0{
        final String servletPath = GreeterServlet.class.getAnnotation(WebServlet.class).urlPatterns()[0];
        final URLConnection response = new URL("http://localhost:8080/test" + servletPath).openConnection();
        BufferedReader in = new BufferedReader(new InputStreamReader(response.getInputStream()));
        final String result = in.readLine();
}


Instance 83

Class540.main(String[] args){
        Socket socket = new Socket(HOST, PORT);
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
        String string = reader.readLine();
}


Instance 84

Class290.promptForPath(CommandRunnerParams params,String prompt)#1{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String path = br.readLine();
    if (path != null) {
      return expandTilde(path.trim());
    }
}


Instance 85

Class250.readIntFromConsole(){
    stdIn = new BufferedReader(new InputStreamReader(System.in));
      String line = stdIn.readLine();
      return Integer.parseInt(line);
}


Instance 86

Class480.readFirstLineFromRsrc(String wktRsrcPath)#0{
    InputStream is = getClass().getResourceAsStream(wktRsrcPath);
    assertNotNull(is);
      BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
      return br.readLine();
}


Instance 87

Class320.locateOSGi()#0{
        BufferedReader factoryReader = new BufferedReader(new InputStreamReader(
             getClass().getClassLoader().getResourceAsStream("META-INF/services/org.osgi.framework.launch.FrameworkFactory")));
        factoryClass = factoryReader.readLine();
        factoryClass = factoryClass.trim();
}


Instance 88

Class20.testSlaves(){
        ClassLoader classLoader = Thread.currentThread()
                .getContextClassLoader();
        BufferedReader in = new BufferedReader(new InputStreamReader(
                classLoader.getResource("slaves").openStream()));
        String line = in.readLine();
}


Instance 89

Class180.doTest(String uri){
        HttpURLConnection conn = getConnection(uri, PORT);
        assertEquals(200, conn.getResponseCode());
        BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        return reader.readLine();
}


Instance 90

Class610.shouldHandleNullStreams1(){
            InputStream stream = InputStreamMerger.merge(null, stream2, stream3);
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String result = reader.readLine();
            assertEquals(expected, result);
}


Instance 91

Class240.readLine()#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
      input = reader.readLine().trim();
}


Instance 92

Class230.getContents(){
        this.channel.write(smallerBuffer);
        final BufferedReader reader = new BufferedReader(new InputStreamReader(this.channel.getContents()));
        final String contents = reader.readLine();
        Assert.assertEquals("Contents read were not as expected", CONTENTS_SMALLER_BUFFER, contents);
}


Instance 93

Class360.signedRequest()#0{
        BufferedReader br = new BufferedReader(new InputStreamReader(baseUrl.openStream()));
        Assert.assertEquals("OK", br.readLine());
}


Instance 94

Class680.openStream(){
        this.asset.write(buffer);
        final BufferedReader reader = new BufferedReader(new InputStreamReader(this.asset.openStream()));
        final String contents = reader.readLine();
        Assert.assertEquals("Contents read were not as expected", CONTENTS_BUFFER, contents);
}


Instance 95

Class50.testCheckForBomNoBom(){
    ByteArrayInputStream stream = new ByteArrayInputStream("test".getBytes());
    ByteOrderMark bom = PropertiesHelper.checkForBom(stream);
    assertNull(bom);
    BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
    assertEquals("The reader must contain everything after the bom", "test", reader.readLine());
}


Instance 96

Class250.readline(){
  BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  return in.readLine();
}


Instance 97

Class190.readLine()#0{
                    new BufferedReader(new InputStreamReader(System.in));
            return reader.readLine();
}


Instance 98

Class720.perform(InputStream inputStream)#0{
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    assertNull(bufferedReader.readLine());
}


Instance 99

Class30.readResponse(InputStream in)#2{
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    String p = br.readLine();
}


Instance 100

Class210.readObject(InputStream stream)#1{
      BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
      String toAdd = reader.readLine();
}


Instance 101

Class700.readSha1(InputStream is){
        final BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            return reader.readLine();
            safeClose(reader);
}


Instance 102

Class0.getInput()#1{
      BufferedReader stdin = new BufferedReader(new InputStreamReader(
            System.in));
         return stdin.readLine();
}


Instance 103

Class710.readLine()#0{
                    new BufferedReader(new InputStreamReader(System.in));
            br.readLine();
}


Instance 104

Class510.printMappings(){
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("/proc/self/maps")));
            for (String line; (line = br.readLine()) != null; ) {
                System.out.println(line);
            }
            br.close();
}


Instance 105

Class660.testAllManPages(){
      InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("help");
      BufferedReader r = new BufferedReader(new InputStreamReader(is));
      for(String name = r.readLine(); name != null; name = r.readLine()) {
         testManPage("help/"+name);
      }
      r.close();
}


Instance 106

Class280.execAndGetOutput(ProcessBuilder builder){
    Process process = builder.redirectErrorStream(true).start();
    BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
      return reader.readLine();
      reader.close();
}


Instance 107

Class570.getFactoryClassName()#0{
    InputStream input = getClass().getClassLoader().getResourceAsStream(serviceId);
    if (input != null) {
      BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
      className = reader.readLine();
      reader.close();
    }
}


Instance 108

Class300.call(){
                FileInputStream is = new FileInputStream(pidFile);
                        new BufferedReader(new InputStreamReader(is));
                pidval = bufR.readLine();
                bufR.close();
                return (Integer.parseInt(pidval));
}


Instance 109

Class180.FileDescription(InputStream data,String mimeType,long lastModified){
                BufferedReader reader = new BufferedReader(new InputStreamReader(data));
                this.content = reader.readLine();
                reader.close();
}


Instance 110

Class740.getConfirmation(File location)#0{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            answer = br.readLine();
            br.close();
}


Instance 111

Class180.printResponse(InputStream in)#0{
      in.close();
    BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
    for (String line; (line = reader.readLine()) != null; ) {
      System.out.println(line);
    }
}


Instance 112

Class0.loadFileAsString(InputStream is)#0{
    BufferedReader r = new BufferedReader(new InputStreamReader(is));
    for (String line = r.readLine(); line != null; line = r.readLine()) {
      sb.append(line);
      sb.append("\n");
    }
    return sb.toString();
}


Instance 113

Class620.fromJSON(final InputStream stream)#0{
        final BufferedReader in = new BufferedReader(new InputStreamReader(stream));
        for (String s = in.readLine(); s != null; s = in.readLine()) {
            buf.append(s).append("\n");
        }
}


Instance 114

Class140.readStream(InputStream errStream)#0{
    BufferedReader in = new BufferedReader(new InputStreamReader(errStream, "UTF-8"));
    for (String line = in.readLine(); line != null; line = in.readLine()) {
      builder.append(line);
      builder.append('\n');
    }
    return builder.toString();
}


Instance 115

Class590.run()#0{
                    new BufferedReader(new InputStreamReader(this.is));
                for (String line = null; (line = br.readLine()) != null;) {
                    this.sink.append(line);
                }
}


Instance 116

Class440.queryAdminServer(String urlStr){
        URL url = new URL(urlStr);
        BufferedReader dis = new BufferedReader(new InputStreamReader((url.openStream())));
        String line = dis.readLine();
        Assert.assertTrue(line.length() > 0);
}


Instance 117

Class480.getIpv2(){
    URL whatismyip = new URL("http://checkip.amazonaws.com");
    BufferedReader in = new BufferedReader(new InputStreamReader(whatismyip.openStream()));
    String ip = in.readLine();
    Closeables.close(in, true);
}


Instance 118

Class160.testNullValueForInjectionPoint(@ArquillianResource(TestServlet.class) URL baseURL){
        final URL url = new URL(baseURL, "ProducerNullIPServlet");
        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
        assertEquals(reader.readLine(), "Test Sucessful!");
}


Instance 119

Class340.getExternalIP()#0{
            URL url = new URL("http://checkip.amazonaws.com");
            BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
            return in.readLine();
}


Instance 120

Class190.getString(String option){
                Process p = Runtime.getRuntime().exec(new String[] { ID_CMD, option });
                BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
                return r.readLine();
}


Instance 121

Class170.readData(String dest)#0{
            HttpURLConnection con = (HttpURLConnection) new URL(dest).openConnection();
                BufferedReader reader = new BufferedReader(new InputStreamReader(con.getInputStream()));
                return reader.readLine();
}


Instance 122

Class50.getCountryFromGeoIP(){
    URL u = new URL("http://www.geogebra.org/geoip/");
    URLConnection uc = u.openConnection();
    uc.setReadTimeout(3000);
    in = new BufferedReader(new InputStreamReader(uc.getInputStream()));
    return in.readLine(); // the last line will never get a "\n" on its end
}


Instance 123

Class490.testRead(int port)#0{
        String url = new URL("http","localhost",port,"/").toString();
        HttpResponse response = new DefaultHttpClient().execute(new HttpGet(url));
        assertEquals(200, response.getStatusLine().getStatusCode());
        InputStream is = response.getEntity().getContent();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String data = br.readLine();
}


Instance 124

Class390.readString(final URL url)#0{
        final InputStream in = url.openStream();
            final BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            return reader.readLine();
}


Instance 125

Class540.read(Socket socket,Class messageClass)#0{
        logger.trace("read message", messageClass, socket.getInputStream().available());
        InputStreamReader reader = new InputStreamReader(socket.getInputStream());
        BufferedReader br = new BufferedReader(reader);
        String json = br.readLine();
        logger.trace("read json", json); 
}


Instance 126

Class280.resolvePath(Path other)#0{
        BufferedReader reader = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("/" + FILE_BASEDIR)));
            return Paths.get(reader.readLine()).resolve(other);
}


Instance 127

Class510.testDefaultEncoding(){
    final IReportVisitor visitor = formatter.createVisitor(output);
    visitor.visitInfo(infos, data);
    driver.sendBundle(visitor);
    final BufferedReader reader = new BufferedReader(new InputStreamReader(
        output.getContentsAsStream(), "UTF-8"));
    final String line = reader.readLine();
    assertTrue(line,
        line.startsWith("<?xml version=\"1.0\" encoding=\"UTF-8\""));
}


Instance 128

Class370.testSetEncoding(){
    formatter.setOutputEncoding("UTF-16");
    driver.sendBundle(formatter.createVisitor(output));
    final BufferedReader reader = new BufferedReader(new InputStreamReader(
        output.getFileAsStream("index.html"), "UTF-16"));
    final String line = reader.readLine();
    assertTrue(line,
        line.startsWith("<?xml version=\"1.0\" encoding=\"UTF-16\""));
}


Instance 129

Class40.shouldHandleNullStreams3(){
            InputStream stream = InputStreamMerger.merge(stream1, stream2, null);
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String result = reader.readLine();
            assertEquals(expected, result);
}


Instance 130

Class40.readStringFromStdin(String message){
        BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
        return reader.readLine().trim();
}


Instance 131

Class400.stop(BundleContext context){
    InputStreamReader isr = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);
    System.out.println(br.readLine().trim().toUpperCase());
}


Instance 132

Class620.assertReadText(Path f)#1{
    InputStream ir = StreamUtils.inputStream(f);
    InputStreamReader in = new InputStreamReader(ir, StandardCharsets.UTF_8);
    BufferedReader r = new BufferedReader(in);
    String line = r.readLine();
}


Instance 133

Class440.doGet(HttpServletRequest req,HttpServletResponse resp)#1{
        ServletInputStream in = req.getInputStream();
        BufferedReader r = new BufferedReader(new InputStreamReader(in));
        String line = r.readLine();
}


Instance 134

Class440.readConsole()#1{
    BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
      return console.readLine();
}


Instance 135

Class670.readFirstLine(InputStream input)#0{
      final BufferedReader reader = new BufferedReader(new InputStreamReader(input));
      return reader.readLine();
}


Instance 136

Class750.readInput(){
        reader = new InputStreamReader(is, "UTF-8");
        BufferedReader br = new BufferedReader(reader);
        return br.readLine();
}


Instance 137

Class460.main(String[] args){
    OutputStream out = new FileOutputStream("out.txt");
    System.setIn(new TeeInputStream(System.in, out));
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String name = reader.readLine();
}


Instance 138

Class590.main(String[] args){
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String name = in.readLine();
}


Instance 139

Class690.receiveEvent(){
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      return br.readLine();
}


Instance 140

Class360.shouldWrapAStringAsAStream(){
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream1));
            String result = reader.readLine();
            assertEquals(STREAM_DATA1, result);
}


Instance 141

Class10.readFrom(Class<Date> arg0,Type arg1,Annotation[] arg2,MediaType arg3,MultivaluedMap<String,String> arg4,InputStream arg5)#0{
         InputStreamReader reader = new InputStreamReader(arg5);
         BufferedReader br = new BufferedReader(reader);
         long date = Long.parseLong(br.readLine());
         return new Date(date);
}


Instance 142

Class430.waitForButton(){
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    line = in.readLine();
}


Instance 143

Class220.read(){
      = new BufferedReader(new InputStreamReader(System.in));
    return reader.readLine();
}


Instance 144

Class210.readText(String text,Object... args)#0{
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
                return reader.readLine();
}


Instance 145

Class600.shouldMergeMultipleInputStreams(){
            BufferedReader reader = new BufferedReader(new InputStreamReader(combinedStream));
            String result = reader.readLine();
            assertEquals(STREAM_DATA1 + STREAM_DATA2 + STREAM_DATA3, result);
}


Instance 146

Class540.main(String[] args)#0{
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        outputStream.write(reader.readLine().getBytes());
}


Instance 147

Class520.readParamFromCommand(String message){
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        return String.valueOf(br.readLine()).trim();
}


Instance 148

Class470.waitForKey(final String preMessage)#0{
        final BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
            System.err.println(stdin.readLine());
}


Instance 149

Class0.ask(){
        BufferedReader stdin = new BufferedReader( new InputStreamReader( System.in ) );
            return stdin.readLine();
}


Instance 150

Class280.handleRequest(final Socket socket)#0{
        final BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        final PrintWriter writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
        do {
            request = reader.readLine();
        } while (handleRequest(writer, request));
        writer.close();
}